/*
 * Auto generated C++ header for Mass Effect 2.
 *	by _silencer.
 */

#ifndef UNREAL_SDK_GAME_Core_H
#define UNREAL_SDK_GAME_Core_H

#include "unreal_game_global.h"

namespace game
{
	using namespace unreal;

	const char* DegToUU = 182.04444;
	const char* UUToDeg = 0.005493;
	const char* INDEX_NONE = -1;
	const char* DegToRad = 0.017453292;
	const char* RadToDeg = 57.29577951;
	const char* Pi = 3.14159265;
	const char* MaxInt = 0x7fff;
	const char* INVALID_STRINGREF = 0;

	enum ETickingGroup
	{
		TG_PreAsyncWork,
		TG_DuringAsyncWork,
		TG_PostAsyncWork,
	};

	enum EInterpMethodType
	{
		IMT_UseFixedTangentEval,
		IMT_UseBrokenTangentEval,
	};

	enum EInterpCurveMode
	{
		CIM_Linear,
		CIM_CurveAuto,
		CIM_Constant,
	};

	enum EInputEvent
	{
		IE_Pressed,
		IE_Released,
		IE_Repeat,
	};

	enum EAxis
	{
		AXIS_NONE,
		AXIS_X,
		AXIS_Y,
	};

	struct RenderCommandFence
	{
		Int NumPendingFences; //offset = 0, size = 4
	};

	struct RawDistribution
	{
		Byte Type; //offset = 0, size = 1
		Byte Op; //offset = 1, size = 1
		Byte LookupTableNumElements; //offset = 2, size = 1
		Byte LookupTableChunkSize; //offset = 3, size = 1
		Array<Float> LookupTable; //offset = 4, size = 12
		Float LookupTableTimeScale; //offset = 16, size = 4
		Float LookupTableStartTime; //offset = 20, size = 4
	};

	struct InterpCurvePointQuat
	{
		Float InVal; //offset = 0, size = 4
		Quat OutVal; //offset = 4, size = 16
		Quat ArriveTangent; //offset = 20, size = 16
		Quat LeaveTangent; //offset = 36, size = 16
		Byte InterpMode; //offset = 52, size = 1
	};

	struct InterpCurveQuat
	{
		Array<InterpCurvePointQuat> Points; //offset = 0, size = 12
		Byte InterpMethod; //offset = 12, size = 1
	};

	struct InterpCurvePointTwoVectors
	{
		Float InVal; //offset = 0, size = 4
		TwoVectors OutVal; //offset = 4, size = 24
		TwoVectors ArriveTangent; //offset = 28, size = 24
		TwoVectors LeaveTangent; //offset = 52, size = 24
		Byte InterpMode; //offset = 76, size = 1
	};

	struct InterpCurveTwoVectors
	{
		Array<InterpCurvePointTwoVectors> Points; //offset = 0, size = 12
		Byte InterpMethod; //offset = 12, size = 1
	};

	struct InterpCurvePointVector
	{
		Float InVal; //offset = 0, size = 4
		Vector OutVal; //offset = 4, size = 12
		Vector ArriveTangent; //offset = 16, size = 12
		Vector LeaveTangent; //offset = 28, size = 12
		Byte InterpMode; //offset = 40, size = 1
	};

	struct InterpCurveVector
	{
		Array<InterpCurvePointVector> Points; //offset = 0, size = 12
		Byte InterpMethod; //offset = 12, size = 1
	};

	struct InterpCurvePointVector2D
	{
		Float InVal; //offset = 0, size = 4
		Vector2D OutVal; //offset = 4, size = 8
		Vector2D ArriveTangent; //offset = 12, size = 8
		Vector2D LeaveTangent; //offset = 20, size = 8
		Byte InterpMode; //offset = 28, size = 1
	};

	struct InterpCurveVector2D
	{
		Array<InterpCurvePointVector2D> Points; //offset = 0, size = 12
		Byte InterpMethod; //offset = 12, size = 1
	};

	struct InterpCurvePointFloat
	{
		Float InVal; //offset = 0, size = 4
		Float OutVal; //offset = 4, size = 4
		Float ArriveTangent; //offset = 8, size = 4
		Float LeaveTangent; //offset = 12, size = 4
		Byte InterpMode; //offset = 16, size = 1
	};

	struct InterpCurveFloat
	{
		Array<InterpCurvePointFloat> Points; //offset = 0, size = 12
		Byte InterpMethod; //offset = 12, size = 1
	};

	struct Cylinder
	{
		Float Radius; //offset = 0, size = 4
		Float Height; //offset = 4, size = 4
	};

	struct Matrix
	{
		Plane XPlane; //offset = 0, size = 16
		Plane YPlane; //offset = 16, size = 16
		Plane ZPlane; //offset = 32, size = 16
		Plane WPlane; //offset = 48, size = 16
	};

	struct BoxSphereBounds
	{
		Vector Origin; //offset = 0, size = 12
		Vector BoxExtent; //offset = 12, size = 12
		Float SphereRadius; //offset = 24, size = 4
	};

	struct Box
	{
		Vector Min; //offset = 0, size = 12
		Vector Max; //offset = 12, size = 12
		Byte IsValid; //offset = 24, size = 1
	};

	struct LinearColor
	{
		Float R; //offset = 0, size = 4
		Float G; //offset = 4, size = 4
		Float B; //offset = 8, size = 4
		Float A; //offset = 12, size = 4
	};

	struct Color
	{
		Byte B; //offset = 0, size = 1
		Byte G; //offset = 1, size = 1
		Byte R; //offset = 2, size = 1
		Byte A; //offset = 3, size = 1
	};

	struct TPOV
	{
		Vector Location; //offset = 0, size = 12
		Rotator Rotation; //offset = 12, size = 12
		Float FOV; //offset = 24, size = 4
	};

	struct SHVector
	{
		Float V[9]; //offset = 0, size = 4
	};

	struct SHVectorRGB
	{
		SHVector R; //offset = 0, size = 36
		SHVector G; //offset = 36, size = 36
		SHVector B; //offset = 72, size = 36
	};

	struct IntPoint
	{
		Int X; //offset = 0, size = 4
		Int Y; //offset = 4, size = 4
	};

	struct Quat
	{
		Float X; //offset = 0, size = 4
		Float Y; //offset = 4, size = 4
		Float Z; //offset = 8, size = 4
		Float W; //offset = 12, size = 4
	};

	struct Rotator
	{
		Int Pitch; //offset = 0, size = 4
		Int Yaw; //offset = 4, size = 4
		Int Roll; //offset = 8, size = 4
	};

	struct Plane
	{
		Float W; //offset = 12, size = 4
	};

	struct TwoVectors
	{
		Vector v1; //offset = 0, size = 12
		Vector v2; //offset = 12, size = 12
	};

	struct Vector2D
	{
		Float X; //offset = 0, size = 4
		Float Y; //offset = 4, size = 4
	};

	struct Vector4
	{
		Float X; //offset = 0, size = 4
		Float Y; //offset = 4, size = 4
		Float Z; //offset = 8, size = 4
		Float W; //offset = 12, size = 4
	};

	struct Vector
	{
		Float X; //offset = 0, size = 4
		Float Y; //offset = 4, size = 4
		Float Z; //offset = 8, size = 4
	};

	struct Guid
	{
		Int A; //offset = 0, size = 4
		Int B; //offset = 4, size = 4
		Int C; //offset = 8, size = 4
		Int D; //offset = 12, size = 4
	};

	struct IndirectArray_Mirror
	{
		Pointer Data; //offset = 0, size = 4
		Int ArrayNum; //offset = 4, size = 4
		Int ArrayMax; //offset = 8, size = 4
	};

	struct UntypedBulkData_Mirror
	{
		Pointer VfTable; //offset = 0, size = 4
		Int BulkDataFlags; //offset = 4, size = 4
		Int ElementCount; //offset = 8, size = 4
		Int BulkDataOffsetInFile; //offset = 12, size = 4
		Int BulkDataSizeOnDisk; //offset = 16, size = 4
		Int SavedBulkDataFlags; //offset = 20, size = 4
		Int SavedElementCount; //offset = 24, size = 4
		Int SavedBulkDataOffsetInFile; //offset = 28, size = 4
		Int SavedBulkDataSizeOnDisk; //offset = 32, size = 4
		Pointer BulkData; //offset = 36, size = 4
		Int LockStatus; //offset = 40, size = 4
		Pointer AttachedAr; //offset = 44, size = 4
		Int bShouldFreeOnEmpty; //offset = 48, size = 4
	};

	struct MultiMap_Mirror
	{
		Pointer Pairs; //offset = 0, size = 4
		Int PairNum; //offset = 4, size = 4
		Int PairMax; //offset = 8, size = 4
		Pointer Hash; //offset = 12, size = 4
		Int HashNum; //offset = 16, size = 4
	};

	struct Map_Mirror
	{
		Pointer Pairs; //offset = 0, size = 4
		Int PairNum; //offset = 4, size = 4
		Int PairMax; //offset = 8, size = 4
		Pointer Hash; //offset = 12, size = 4
		Int HashNum; //offset = 16, size = 4
	};

	struct DynamicMap_Mirror
	{
		Pointer Hash; //offset = 0, size = 4
		Int HashSize; //offset = 4, size = 4
		Int Count; //offset = 8, size = 4
		Array<Int> Pairs; //offset = 12, size = 12
		Pointer FreePairs; //offset = 24, size = 4
	};

	struct ThreadSafeCounter
	{
		Int Value; //offset = 0, size = 4
	};

	struct Double
	{
		Int A; //offset = 0, size = 4
		Int B; //offset = 4, size = 4
	};

	struct SFXTokenMapping
	{
		Int TokenId; //offset = 0, size = 4
		String Data; //offset = 4, size = 12
	};

	struct QWord
	{
		Int A; //offset = 0, size = 4
		Int B; //offset = 4, size = 4
	};

	struct Pointer
	{
		Int Dummy; //offset = 0, size = 4
	};

	class Object: public Object
	{
		DECLARE_PACKAGE_CLASS( Object, Object, Core )

	public:

		Pointer VfTableObject; //offset = 0, size = 4
		Int ObjectInternalInteger; //offset = 4, size = 4
		QWord ObjectFlags; //offset = 8, size = 8
		Pointer HashNext; //offset = 16, size = 4
		Pointer HashOuterNext; //offset = 20, size = 4
		Pointer StateFrame; //offset = 24, size = 4
		Object* Linker; //offset = 28, size = 4
		Pointer LinkerIndex; //offset = 32, size = 4
		Int NetIndex; //offset = 36, size = 4
		Object* Outer; //offset = 40, size = 4
		Name Name; //offset = 44, size = 8
		Class* Class; //offset = 52, size = 4
		Object* ObjectArchetype; //offset = 56, size = 4

		Int GetNetIndex();
		void appScreenDebugMessage( String sMsg );
		Vector TransformVectorByRotation( Rotator SourceRotation, Vector SourceVector, Bool bInverse );
		Name GetPackageName(, Object* O );
		Bool IsPendingKill();
		Float ByteToFloat( Byte inputByte, Bool bSigned );
		Byte FloatToByte( Float inputFloat, Bool bSigned );
		Float UnwindHeading( Float A );
		Float FindDeltaAngle( Float A1, Float A2, Float Delta );
		Float GetHeadingAngle( Vector Dir, Float Angle );
		void GetAngularDegreesFromRadians( Vector2D OutFOV );
		void GetAngularFromDotDist( Vector2D OutAngDist, Vector2D DotDist );
		Bool GetAngularDistance( Vector2D OutAngularDist, Vector Direction, Vector AxisX, Vector AxisY, Vector AxisZ );
		Bool GetDotDistance( Vector2D OutDotDist, Vector Direction, Vector AxisX, Vector AxisY, Vector AxisZ );
		Bool PointInBox( Vector Point, Vector Location, Vector Extent, Vector MinBox, Vector MaxBox );
		Float PointDistToPlane( Vector Point, Rotator Orientation, Vector Origin, Vector out_ClosestPoint, Vector AxisX, Vector AxisY, Vector AxisZ, Vector PointNoZ, Vector OriginNoZ, Float fPointZ, Float fProjDistToAxis );
		Float PointDistToLine( Vector Point, Vector Line, Vector Origin, Vector OutClosestPoint );
		Bool GetPerObjectConfigSections( Class* SearchClass, Array<String> out_SectionNames, Object* ObjectOuter, Int MaxResults );
		void StaticSaveConfig();
		void SaveConfig();
		Object* FindObject( String ObjectName, Class* ObjectClass );
		Object* DynamicLoadObject( String ObjectName, Class* ObjectClass, Bool MayFail );
		Int GetEnumIndex( Object* E, Name valuename );
		Name GetEnum( Object* E, Int I );
		void Disable( Name ProbeFunc );
		void Enable( Name ProbeFunc );
		void ContinuedState();
		void PausedState();
		void PoppedState();
		void PushedState();
		void EndState( Name NextStateName );
		void BeginState( Name PreviousStateName );
		void DumpStateStack();
		void PopState( Bool bPopAll );
		void PushState( Name NewState, Name NewLabel );
		Name GetStateName();
		Bool IsChildState( Name TestState, Name TestParentState );
		Bool IsInState( Name TestState, Bool bTestStateStack );
		void GotoState( Name NewState, Name Label, Bool bForceEvents, Bool bKeepStack );
		void ReadSaveObject( BioBaseSaveObject* Save );
		BioBaseSaveObject* WriteSaveObject( Object* InOuter, BioBaseSaveObject* Save, Class* SaveClass );
		Class* GetSaveObjectClass();
		void CopyToSaveObject( BioBaseSaveObject* Save );
		void CopyFromSaveObject( BioBaseSaveObject* Save );
		Object* BioDuplicate( Object* DupObject, Object* InOuter );
		Bool IsUTracing();
		void SetUTracing( Bool bShouldUTrace );
		Name GetFuncName();
		void ScriptTrace();
		String Localize( String SectionName, String KeyName, String PackageName );
		void WarnInternal( String S );
		void LogInternal( String S, Name Tag );
		LinearColor Subtract_LinearColorLinearColor( LinearColor A, LinearColor B );
		LinearColor Multiply_LinearColorFloat( LinearColor LC, Float Mult );
		LinearColor ColorToLinearColor( Color OldColor );
		LinearColor MakeLinearColor( Float R, Float G, Float B, Float A, LinearColor LC );
		Color MakeColor( Byte R, Byte G, Byte B, Byte A, Color C );
		Color Add_ColorColor( Color A, Color B );
		Color Multiply_ColorFloat( Color A, Float B );
		Color Multiply_FloatColor( Float A, Color B );
		Color Subtract_ColorColor( Color A, Color B );
		Vector2D vect2d( Float InX, Float InY, Vector2D NewVect2d );
		Float GetRangePctByValue( Vector2D Range, Float Value );
		Float GetRangeValueByPct( Vector2D Range, Float Pct );
		Int GetVectorAboveBelow( Vector A, Vector B, Vector PlaneNormal );
		Int GetVectorSide( Vector A, Vector B );
		Float GetAngleBetween( Vector A, Vector B );
		Bool NotEqual_IntStringRef( Int A, B B );
		Bool NotEqual_StringRefInt( A A, Int B );
		Bool NotEqual_StringRefStringRef( A A, B B );
		Bool EqualEqual_IntStringRef( Int A, B B );
		Bool EqualEqual_StringRefInt( A A, Int B );
		Bool EqualEqual_StringRefStringRef( A A, B B );
		Quat Subtract_QuatQuat( Quat A, Quat B );
		Quat Add_QuatQuat( Quat A, Quat B );
		Quat QuatSlerp( Quat A, Quat B, Float Alpha, Bool bShortestPath );
		Rotator QuatToRotator( Quat A );
		Quat QuatFromRotator( Rotator A );
		Quat QuatFromAxisAndAngle( Vector Axis, Float Angle );
		Quat QuatFindBetween( Vector A, Vector B );
		Vector QuatRotateVector( Quat A, Vector B );
		Quat QuatInvert( Quat A );
		Float QuatDot( Quat A, Quat B );
		Quat QuatProduct( Quat A, Quat B );
		Bool NotEqual_NameName( Name A, Name B );
		Bool EqualEqual_NameName( Name A, Name B );
		Bool IsA( Name ClassName );
		Bool ClassIsChildOf( Class* TestClass, Class* ParentClass );
		Bool NotEqual_InterfaceInterface( A A, B B );
		Bool EqualEqual_InterfaceInterface( A A, B B );
		Bool NotEqual_ObjectObject( Object* A, Object* B );
		Bool EqualEqual_ObjectObject( Object* A, Object* B );
		String PathName( Object* CheckObject );
		void ParseStringIntoArray( String BaseString, Array<String> Pieces, String delim, Bool bCullEmpty );
		void JoinArray( Array<String> StringArray, String out_Result, String delim, Bool bIgnoreBlanks, Int I );
		String GetRightMost( String Text, Int strIdx );
		String Split( String Text, String SplitStr, Bool bOmitSplitStr, Int pos );
		String Repl( String Src, String Match, String With, Bool bCaseSensitive );
		Int Asc( String S );
		String Chr( Int I );
		String Locs( String S );
		String Caps( String S );
		String Right( String S, Int I );
		String Left( String S, Int I );
		String Mid( String S, Int I, Int J );
		Int InStr( String S, String T, Bool bSearchFromRight );
		Int Len( String S );
		String SubtractEqual_StrStr( String A, String B );
		String AtEqual_StrStr( String A, String B );
		String ConcatEqual_StrStr( String A, String B );
		Bool ComplementEqual_StrStr( String A, String B );
		Bool NotEqual_StrStr( String A, String B );
		Bool EqualEqual_StrStr( String A, String B );
		Bool GreaterEqual_StrStr( String A, String B );
		Bool LessEqual_StrStr( String A, String B );
		Bool Greater_StrStr( String A, String B );
		Bool Less_StrStr( String A, String B );
		String At_StrStr( String A, String B );
		String Concat_StrStr( String A, String B );
		Bool SClampRotAxis( Float DeltaTime, Int ViewAxis, Int out_DeltaViewAxis, Int MaxLimit, Int MinLimit, Float InterpolationSpeed, Bool bClamped );
		Int ClampRotAxisFromBase( Int Current, Int Center, Int MaxDelta, Int DeltaFromCenter );
		void ClampRotAxis( Int ViewAxis, Int out_DeltaViewAxis, Int MaxLimit, Int MinLimit, Int DesiredViewAxis );
		Float RSize( Rotator R, Int PitchNorm, Int YawNorm, Int RollNorm );
		Float RDiff( Rotator A, Rotator B );
		Int NormalizeRotAxis( Int Angle );
		Rotator RInterpTo( Rotator Current, Rotator Target, Float DeltaTime, Float InterpSpeed );
		Rotator RSmerp( Rotator A, Rotator B, Float Alpha, Bool bShortestPath );
		Rotator RLerp( Rotator A, Rotator B, Float Alpha, Bool bShortestPath );
		Rotator Normalize( Rotator Rot );
		Rotator OrthoRotation( Vector X, Vector Y, Vector Z );
		Rotator RotRand( Bool bRoll );
		void GetUnAxes( Rotator A, Vector X, Vector Y, Vector Z );
		void GetAxes( Rotator A, Vector X, Vector Y, Vector Z );
		Bool ClockwiseFrom_IntInt( Int A, Int B );
		Rotator SubtractEqual_RotatorRotator( Rotator A, Rotator B );
		Rotator AddEqual_RotatorRotator( Rotator A, Rotator B );
		Rotator Subtract_RotatorRotator( Rotator A, Rotator B );
		Rotator Add_RotatorRotator( Rotator A, Rotator B );
		Rotator DivideEqual_RotatorFloat( Rotator A, Float B );
		Rotator MultiplyEqual_RotatorFloat( Rotator A, Float B );
		Rotator Divide_RotatorFloat( Rotator A, Float B );
		Rotator Multiply_FloatRotator( Float A, Rotator B );
		Rotator Multiply_RotatorFloat( Rotator A, Float B );
		Bool NotEqual_RotatorRotator( Rotator A, Rotator B );
		Bool EqualEqual_RotatorRotator( Rotator A, Rotator B );
		Vector ClampLength( Vector V, Float MaxLength );
		Vector VInterpTo( Vector Current, Vector Target, Float DeltaTime, Float InterpSpeed );
		Bool IsZero( Vector A );
		Vector ProjectOnTo( Vector X, Vector Y );
		Vector MirrorVectorByNormal( Vector InVect, Vector InNormal );
		Vector VRand();
		Vector VSmerp( Vector A, Vector B, Float Alpha );
		Vector VLerp( Vector A, Vector B, Float Alpha );
		Vector Normal( Vector A );
		Float VSizeSq2D( Vector A );
		Float VSizeSq( Vector A );
		Float VSize2D( Vector A );
		Float VSize( Vector A );
		Vector SubtractEqual_VectorVector( Vector A, Vector B );
		Vector AddEqual_VectorVector( Vector A, Vector B );
		Vector DivideEqual_VectorFloat( Vector A, Float B );
		Vector MultiplyEqual_VectorVector( Vector A, Vector B );
		Vector MultiplyEqual_VectorFloat( Vector A, Float B );
		Vector Cross_VectorVector( Vector A, Vector B );
		Float Dot_VectorVector( Vector A, Vector B );
		Bool NotEqual_VectorVector( Vector A, Vector B );
		Bool EqualEqual_VectorVector( Vector A, Vector B );
		Vector GreaterGreater_VectorRotator( Vector A, Rotator B );
		Vector LessLess_VectorRotator( Vector A, Rotator B );
		Vector Subtract_VectorVector( Vector A, Vector B );
		Vector Add_VectorVector( Vector A, Vector B );
		Vector Divide_VectorFloat( Vector A, Float B );
		Vector Multiply_VectorVector( Vector A, Vector B );
		Vector Multiply_FloatVector( Float A, Vector B );
		Vector Multiply_VectorFloat( Vector A, Float B );
		Vector Subtract_PreVector( Vector A );
		String GetTokenisedString( Int srStringID, Array<SFXTokenMapping> TokenList );
		void SetCustomToken( Int nTokenNum, String sToken );
		void ClearCustomTokens();
		Object* DynamicLoadDefaultResource( String sIniKey, Class* ExpectedClass );
		Float FInterpTo( Float Current, Float Target, Float DeltaTime, Float InterpSpeed );
		Float FPctByRange( Float Value, Float InMin, Float InMax );
		Float RandRange( Float InMin, Float InMax );
		Float FInterpEaseInOut( Float A, Float B, Float Alpha, Float Exp );
		Float FInterpEaseOut( Float A, Float B, Float Alpha, Float Exp );
		Float FInterpEaseIn( Float A, Float B, Float Alpha, Float Exp );
		Float FCubicInterp( Float P0, Float T0, Float P1, Float T1, Float A );
		Int Round( Float A );
		Float Lerp( Float A, Float B, Float Alpha );
		Float FClamp( Float V, Float A, Float B );
		Float FMax( Float A, Float B );
		Float FMin( Float A, Float B );
		Float FRand();
		Float Square( Float A );
		Float Sqrt( Float A );
		Float Loge( Float A );
		Float Exp( Float A );
		Float Atan( Float A, Float B );
		Float Tan( Float A );
		Float Acos( Float A );
		Float Cos( Float A );
		Float Asin( Float A );
		Float Sin( Float A );
		Float Abs( Float A );
		Float SubtractEqual_FloatFloat( Float A, Float B );
		Float AddEqual_FloatFloat( Float A, Float B );
		Float DivideEqual_FloatFloat( Float A, Float B );
		Float MultiplyEqual_FloatFloat( Float A, Float B );
		Bool NotEqual_FloatFloat( Float A, Float B );
		Bool ComplementEqual_FloatFloat( Float A, Float B );
		Bool EqualEqual_FloatFloat( Float A, Float B );
		Bool GreaterEqual_FloatFloat( Float A, Float B );
		Bool LessEqual_FloatFloat( Float A, Float B );
		Bool Greater_FloatFloat( Float A, Float B );
		Bool Less_FloatFloat( Float A, Float B );
		Float Subtract_FloatFloat( Float A, Float B );
		Float Add_FloatFloat( Float A, Float B );
		Float Percent_FloatFloat( Float A, Float B );
		Float Divide_FloatFloat( Float A, Float B );
		Float Multiply_FloatFloat( Float A, Float B );
		Float MultiplyMultiply_FloatFloat( Float Base, Float Exp );
		Float Subtract_PreFloat( Float A );
		String ToHex( Int A );
		Int Clamp( Int V, Int A, Int B );
		Int Max( Int A, Int B );
		Int Min( Int A, Int B );
		Int Rand( Int Max );
		Int SubtractSubtract_Int( Int A );
		Int AddAdd_Int( Int A );
		Int SubtractSubtract_PreInt( Int A );
		Int AddAdd_PreInt( Int A );
		Int SubtractEqual_IntInt( Int A, Int B );
		Int AddEqual_IntInt( Int A, Int B );
		Int DivideEqual_IntFloat( Int A, Float B );
		Int MultiplyEqual_IntFloat( Int A, Float B );
		Int Or_IntInt( Int A, Int B );
		Int Xor_IntInt( Int A, Int B );
		Int And_IntInt( Int A, Int B );
		Bool NotEqual_IntInt( Int A, Int B );
		Bool EqualEqual_IntInt( Int A, Int B );
		Bool GreaterEqual_IntInt( Int A, Int B );
		Bool LessEqual_IntInt( Int A, Int B );
		Bool Greater_IntInt( Int A, Int B );
		Bool Less_IntInt( Int A, Int B );
		Int GreaterGreaterGreater_IntInt( Int A, Int B );
		Int GreaterGreater_IntInt( Int A, Int B );
		Int LessLess_IntInt( Int A, Int B );
		Int Subtract_IntInt( Int A, Int B );
		Int Add_IntInt( Int A, Int B );
		Int Divide_IntInt( Int A, Int B );
		Int Multiply_IntInt( Int A, Int B );
		Int Subtract_PreInt( Int A );
		Int Complement_PreInt( Int A );
		Byte SubtractSubtract_Byte( Byte A );
		Byte AddAdd_Byte( Byte A );
		Byte SubtractSubtract_PreByte( Byte A );
		Byte AddAdd_PreByte( Byte A );
		Byte SubtractEqual_ByteByte( Byte A, Byte B );
		Byte AddEqual_ByteByte( Byte A, Byte B );
		Byte DivideEqual_ByteByte( Byte A, Byte B );
		Byte MultiplyEqual_ByteFloat( Byte A, Float B );
		Byte MultiplyEqual_ByteByte( Byte A, Byte B );
		Bool OrOr_BoolBool( Bool A, Bool B );
		Bool XorXor_BoolBool( Bool A, Bool B );
		Bool AndAnd_BoolBool( Bool A, Bool B );
		Bool NotEqual_BoolBool( Bool A, Bool B );
		Bool EqualEqual_BoolBool( Bool A, Bool B );
		Bool Not_PreBool( Bool A );
	};

	class Factory: public Object
	{
		DECLARE_PACKAGE_CLASS( Factory, Object, Core )

	public:

		Array<String> Formats; //offset = 80, size = 12
		String Description; //offset = 68, size = 12
	};

	class TextBufferFactory: public Factory
	{
		DECLARE_PACKAGE_CLASS( TextBufferFactory, Factory, Core )

	public:
	};

	class TextBuffer: public Object
	{
		DECLARE_PACKAGE_CLASS( TextBuffer, Object, Core )

	public:
	};

	class Subsystem: public Object
	{
		DECLARE_PACKAGE_CLASS( Subsystem, Object, Core )

	public:

		Pointer VfTable_FExec; //offset = 60, size = 4
	};

	class System: public Subsystem
	{
		DECLARE_PACKAGE_CLASS( System, Subsystem, Core )

	public:

		Array<String> SeekFreePCPaths; //offset = 152, size = 12
		Array<String> SeekFreePCExtensions; //offset = 224, size = 12
		Array<String> CutdownPaths; //offset = 188, size = 12
		Array<String> LocalizationPaths; //offset = 236, size = 12
		String TextureFileCacheExtension; //offset = 248, size = 12
		Array<String> Extensions; //offset = 212, size = 12
		Array<Name> Suppress; //offset = 200, size = 12
		Array<String> FRScriptPaths; //offset = 176, size = 12
		Array<String> ScriptPaths; //offset = 164, size = 12
		Array<String> Paths; //offset = 140, size = 12
		String ScreenShotPath; //offset = 128, size = 12
		String CacheExt; //offset = 116, size = 12
		String CachePath; //offset = 104, size = 12
		String SavePath; //offset = 80, size = 12
		Float AsyncIOBandwidthLimit; //offset = 76, size = 4
		Int MaxOverallCacheSize; //offset = 72, size = 4
		Int MaxStaleCacheSize; //offset = 68, size = 4
		Int StaleCacheDays; //offset = 64, size = 4
	};

	class Field: public Object
	{
		DECLARE_PACKAGE_CLASS( Field, Object, Core )

	public:
	};

	class Property: public Field
	{
		DECLARE_PACKAGE_CLASS( Property, Field, Core )

	public:
	};

	class StructProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( StructProperty, Property, Core )

	public:
	};

	class StrProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( StrProperty, Property, Core )

	public:
	};

	class StringRefProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( StringRefProperty, Property, Core )

	public:
	};

	class Struct: public Field
	{
		DECLARE_PACKAGE_CLASS( Struct, Field, Core )

	public:
	};

	class ScriptStruct: public Struct
	{
		DECLARE_PACKAGE_CLASS( ScriptStruct, Struct, Core )

	public:
	};

	class PackageMap: public Object
	{
		DECLARE_PACKAGE_CLASS( PackageMap, Object, Core )

	public:
	};

	class ObjectSerializer: public Object
	{
		DECLARE_PACKAGE_CLASS( ObjectSerializer, Object, Core )

	public:
	};

	class ObjectRedirector: public Object
	{
		DECLARE_PACKAGE_CLASS( ObjectRedirector, Object, Core )

	public:
	};

	class NameProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( NameProperty, Property, Core )

	public:
	};

	class MetaData: public Object
	{
		DECLARE_PACKAGE_CLASS( MetaData, Object, Core )

	public:
	};

	class MapProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( MapProperty, Property, Core )

	public:
	};

	class Linker: public Object
	{
		DECLARE_PACKAGE_CLASS( Linker, Object, Core )

	public:
	};

	class LinkerSave: public Linker
	{
		DECLARE_PACKAGE_CLASS( LinkerSave, Linker, Core )

	public:
	};

	class LinkerLoad: public Linker
	{
		DECLARE_PACKAGE_CLASS( LinkerLoad, Linker, Core )

	public:
	};

	class IntProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( IntProperty, Property, Core )

	public:
	};

	class InterfaceProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( InterfaceProperty, Property, Core )

	public:
	};

	class Interface: public Object
	{
		DECLARE_PACKAGE_CLASS( Interface, Object, Core )

	public:
	};

	class Commandlet: public Object
	{
		DECLARE_PACKAGE_CLASS( Commandlet, Object, Core )

	public:

		String HelpDescription; //offset = 60, size = 12
		String HelpUsage; //offset = 72, size = 12
		String HelpWebLink; //offset = 84, size = 12
		Array<String> HelpParamNames; //offset = 96, size = 12
		Array<String> HelpParamDescriptions; //offset = 108, size = 12
		Bool IsServer: 1; //offset = 120, size = 4
		Bool IsClient: 1; //offset = 120, size = 4
		Bool IsEditor: 1; //offset = 120, size = 4
		Bool LogToConsole: 1; //offset = 120, size = 4
		Bool ShowErrorCount: 1; //offset = 120, size = 4
		Bool BioLoadConsoleSupport: 1; //offset = 120, size = 4

		Int Main( String Params );
	};

	class HelpCommandlet: public Commandlet
	{
		DECLARE_PACKAGE_CLASS( HelpCommandlet, Commandlet, Core )

	public:

		Int Main( String Params );
	};

	class Function: public Struct
	{
		DECLARE_PACKAGE_CLASS( Function, Struct, Core )

	public:
	};

	class FloatProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( FloatProperty, Property, Core )

	public:
	};

	class Exporter: public Object
	{
		DECLARE_PACKAGE_CLASS( Exporter, Object, Core )

	public:

		Array<String> FormatDescription; //offset = 76, size = 12
		Array<String> FormatExtension; //offset = 64, size = 12
	};

	class Enum: public Field
	{
		DECLARE_PACKAGE_CLASS( Enum, Field, Core )

	public:
	};

	class Component: public Object
	{
		DECLARE_PACKAGE_CLASS( Component, Object, Core )

	public:

		Class* TemplateOwnerClass; //offset = 60, size = 4
		Name TemplateName; //offset = 64, size = 8
	};

	enum EDistributionVectorMirrorFlags
	{
		EDVMF_Same,
		EDVMF_Different,
	};

	enum EDistributionVectorLockFlags
	{
		EDVLF_None,
		EDVLF_XY,
		EDVLF_XZ,
	};

	struct RawDistributionVector
	{
		DistributionVector* Distribution; //offset = 24, size = 4
	};

	class DistributionVector: public Component
	{
		DECLARE_PACKAGE_CLASS( DistributionVector, Component, Core )

	public:

		Pointer VfTable_FCurveEdInterface; //offset = 72, size = 4
		Bool bCanBeBaked: 1; //offset = 76, size = 4
		Bool bIsDirty: 1; //offset = 76, size = 4
	};

	struct RawDistributionFloat
	{
		DistributionFloat* Distribution; //offset = 24, size = 4
	};

	class DistributionFloat: public Component
	{
		DECLARE_PACKAGE_CLASS( DistributionFloat, Component, Core )

	public:

		Pointer VfTable_FCurveEdInterface; //offset = 72, size = 4
		Bool bCanBeBaked: 1; //offset = 76, size = 4
		Bool bIsDirty: 1; //offset = 76, size = 4
	};

	class DelegateProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( DelegateProperty, Property, Core )

	public:
	};

	class Const: public Field
	{
		DECLARE_PACKAGE_CLASS( Const, Field, Core )

	public:
	};

	class ObjectProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( ObjectProperty, Property, Core )

	public:
	};

	class ComponentProperty: public ObjectProperty
	{
		DECLARE_PACKAGE_CLASS( ComponentProperty, ObjectProperty, Core )

	public:
	};

	class ClassProperty: public ObjectProperty
	{
		DECLARE_PACKAGE_CLASS( ClassProperty, ObjectProperty, Core )

	public:
	};

	class ByteProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( ByteProperty, Property, Core )

	public:
	};

	class BoolProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( BoolProperty, Property, Core )

	public:
	};

	class BioTelemetry: public Object
	{
		DECLARE_PACKAGE_CLASS( BioTelemetry, Object, Core )

	public:

		void SendEventBool( Name sEventName, Bool nPayload );
		void SendEventInt( Name sEventName, Int nPayload );
		void SendEventString( Name sEventName, String sPayload );
		void SendEventName( Name sEventName, Name sPayload );
		void SendEvent( Name sEventName );
	};

	class BioCoreBaseObject: public Object
	{
		DECLARE_PACKAGE_CLASS( BioCoreBaseObject, Object, Core )

	public:
	};

	struct BioDlgToken
	{
		String sToken; //offset = 0, size = 12
		Int nActionCode; //offset = 12, size = 4
	};

	class BioBaseTokenParser: public Object
	{
		DECLARE_PACKAGE_CLASS( BioBaseTokenParser, Object, Core )

	public:

		Array<BioDlgToken> Tokens; //offset = 60, size = 12

		Bool GetStringToken( Int nActionCode, String sToken );
	};

	class BioBaseTlkFile: public Object
	{
		DECLARE_PACKAGE_CLASS( BioBaseTlkFile, Object, Core )

	public:
	};

	class BioBaseSaveObject: public Object
	{
		DECLARE_PACKAGE_CLASS( BioBaseSaveObject, Object, Core )

	public:

		String OwnerName; //offset = 60, size = 12

		Bool SaveBaseObjectInfo( Object* O );
		void LoadObject( Object* O );
		void SaveObject( Object* O );
	};

	struct BioMissingResourceList
	{
		Int bPackageOutOfDate; //offset = 0, size = 4
		Array<String> MissingResources; //offset = 4, size = 12
	};

	class Package: public Object
	{
		DECLARE_PACKAGE_CLASS( Package, Object, Core )

	public:

		Int bDirty; //offset = 60, size = 4
		Int bDirtyForPIE; //offset = 64, size = 4
		Int bHasBeenFullyLoaded; //offset = 68, size = 4
		Int bShouldFindExportsInMemoryFirst; //offset = 72, size = 4
		Int bIsBound; //offset = 76, size = 4
		Name FolderName; //offset = 80, size = 8
		Int SCCState; //offset = 88, size = 4
		Float LoadTime; //offset = 92, size = 4
		Guid FileGuid; //offset = 96, size = 16
		Int FileSize; //offset = 112, size = 4
		Array<Int> NetObjects; //offset = 116, size = 12
		Int CurrentNumNetObjects; //offset = 128, size = 4
		Array<Int> GenerationNetObjectCount; //offset = 132, size = 12
		Name ForcedExportBasePackageName; //offset = 144, size = 8
		Int PackageFlags; //offset = 152, size = 4
		Int SaveCausesDataLoss; //offset = 156, size = 4
		Map</*Warning unknown type, defaulting to*/ Int, /*Warning unknown type, defaulting to*/ Int> PackageToMissingResourcesMap; //offset = 160, size = 20
		Int bLocked; //offset = 180, size = 4
		Pointer MetaData; //offset = 184, size = 4
	};

	class State: public Struct
	{
		DECLARE_PACKAGE_CLASS( State, Struct, Core )

	public:
	};

	class Class: public State
	{
		DECLARE_PACKAGE_CLASS( Class, State, Core )

	public:
	};

	class ArrayProperty: public Property
	{
		DECLARE_PACKAGE_CLASS( ArrayProperty, Property, Core )

	public:
	};

	class Default__Class: public Object
	{
		DECLARE_PACKAGE_CLASS( Default__Class, Object, Core )

	public:
	};
}

#endif
